home *** CD-ROM | disk | FTP | other *** search
/ Software 2000 / Software 2000 Volume 1 (Disc 1 of 2).iso / utilities / u118.dms / in.adf / iff / ilbm.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-30  |  10.8 KB  |  279 lines
  1. #ifndef ILBM_H
  2. #define ILBM_H
  3. /*----------------------------------------------------------------------*
  4.  * ILBM.H  Definitions for InterLeaved BitMap raster image.     1/23/86
  5.  *
  6.  * By Jerry Morrison and Steve Shaw, Electronic Arts.
  7.  * This software is in the public domain.
  8.  *
  9.  * This version for the Commodore-Amiga computer.
  10.  *----------------------------------------------------------------------*/
  11. #ifndef COMPILER_H
  12. #include "iff/compiler.h"
  13. #endif
  14.  
  15. #ifndef GRAPHICS_GFX_H
  16. #include "graphics/gfx.h"
  17. #endif
  18.  
  19. #include "iff/iff.h"
  20.  
  21. #define ID_ILBM MakeID('I','L','B','M')
  22. #define ID_BMHD MakeID('B','M','H','D')
  23. #define ID_CMAP MakeID('C','M','A','P')
  24. #define ID_GRAB MakeID('G','R','A','B')
  25. #define ID_DEST MakeID('D','E','S','T')
  26. #define ID_SPRT MakeID('S','P','R','T')
  27. #define ID_CAMG MakeID('C','A','M','G')
  28. #define ID_BODY MakeID('B','O','D','Y')
  29.  
  30. /* ---------- BitMapHeader ---------------------------------------------*/
  31.  
  32. typedef UBYTE Masking;        /* Choice of masking technique.*/
  33. #define mskNone                 0
  34. #define mskHasMask              1
  35. #define mskHasTransparentColor  2
  36. #define mskLasso                3
  37.  
  38. typedef UBYTE Compression;    /* Choice of compression algorithm applied to
  39.      * each row of the source and mask planes. "cmpByteRun1" is the byte run
  40.      * encoding generated by Mac's PackBits. See Packer.h . */
  41. #define cmpNone      0
  42. #define cmpByteRun1  1
  43.  
  44. /* Aspect ratios: The proper fraction xAspect/yAspect represents the pixel
  45.  * aspect ratio pixel_width/pixel_height.
  46.  *
  47.  * For the 4 Amiga display modes:
  48.  *   320 x 200: 10/11  (these pixels are taller than they are wide)
  49.  *   320 x 400: 20/11
  50.  *   640 x 200:  5/11
  51.  *   640 x 400: 10/11        */
  52. #define x320x200Aspect 10
  53. #define y320x200Aspect 11
  54. #define x320x400Aspect 20
  55. #define y320x400Aspect 11
  56. #define x640x200Aspect  5
  57. #define y640x200Aspect 11
  58. #define x640x400Aspect 10
  59. #define y640x400Aspect 11
  60.  
  61. /* A BitMapHeader is stored in a BMHD chunk. */
  62. #ifdef NORTHC
  63. /* Bug in NorthC if an unnamed structure type is defined on the same line
  64.    in two different include files, by just calling the structure something 
  65.    we can get round it */
  66. typedef struct _BitMapHeader{
  67. #else
  68. typedef struct {
  69. #endif
  70.     UWORD w, h;            /* raster width & height in pixels */
  71.     WORD  x, y;            /* position for this image */
  72.     UBYTE nPlanes;        /* # source bitplanes */
  73.     Masking masking;        /* masking technique */
  74.     Compression compression;    /* compression algoithm */
  75.     UBYTE pad1;            /* UNUSED.  For consistency, put 0 here.*/
  76.     UWORD transparentColor;    /* transparent "color number" */
  77.     UBYTE xAspect, yAspect;    /* aspect ratio, a rational number x/y */
  78.     WORD  pageWidth, pageHeight;  /* source "page" size in pixels */
  79.     } BitMapHeader;
  80.  
  81. /* RowBytes computes the number of bytes in a row, from the width in pixels.*/
  82. #define RowBytes(w)   (((w) + 15) >> 4 << 1)
  83.  
  84.  
  85. /* ---------- ColorRegister --------------------------------------------*/
  86. /* A CMAP chunk is a packed array of ColorRegisters (3 bytes each). */
  87. #ifdef NORTHC
  88. /* Unnamed structure bug again */
  89. typedef struct _ColorReg {
  90. #else
  91. typedef struct {
  92. #endif
  93.     UBYTE red , green , blue;   /* MUST be UBYTEs so ">> 4" won't sign extend.*/
  94.     } ColorRegister;
  95.  
  96. /* Use this constant instead of sizeof(ColorRegister). */
  97. #define sizeofColorRegister  3
  98.  
  99. typedef WORD Color4;    /* Amiga RAM version of a color-register,
  100.              * with 4 bits each RGB in low 12 bits.*/
  101.  
  102. /* Maximum number of bitplanes in RAM. Current Amiga max w/dual playfield. */
  103. #define MaxAmDepth 6
  104.  
  105. /* ---------- Point2D --------------------------------------------------*/
  106. /* A Point2D is stored in a GRAB chunk. */
  107. typedef struct {
  108.     WORD x, y;        /* coordinates (pixels) */
  109.     } Point2D;
  110.  
  111. /* ---------- DestMerge ------------------------------------------------*/
  112. /* A DestMerge is stored in a DEST chunk. */
  113. #ifdef NORTHC
  114. /* Unnamed structure bug */
  115. typedef struct _DestMerge {
  116. #else
  117. typedef struct {
  118. #endif
  119.     UBYTE depth;    /* # bitplanes in the original source */
  120.     UBYTE pad1;        /* UNUSED; for consistency store 0 here */
  121.     UWORD planePick;    /* how to scatter source bitplanes into destination */
  122.     UWORD planeOnOff;    /* default bitplane data for planePick */
  123.     UWORD planeMask;    /* selects which bitplanes to store into */
  124.     } DestMerge;
  125.  
  126. /* ---------- SpritePrecedence -----------------------------------------*/
  127. /* A SpritePrecedence is stored in a SPRT chunk. */
  128. typedef UWORD SpritePrecedence;
  129.  
  130. /* ---------- Viewport Mode --------------------------------------------*/
  131. /* A Commodore Amiga ViewPort->Modes is stored in a CAMG chunk. */
  132. /* The chunk's content is declared as a LONG. */
  133.  
  134. /* ---------- CRange ---------------------------------------------------*/
  135. /* A CRange is store in a CRNG chunk. */
  136. typedef struct {
  137.     WORD  pad1;        /* reserved for future use; store 0 here */
  138.     WORD  rate;        /* color cycling rate, 16384 = 60 steps/second */
  139.     WORD  active;    /* nonzero means color cycling is turned on */
  140.     UBYTE low, high;    /* lower and upper color registers selected */
  141.     } CRange;
  142.  
  143. /* ---------- ILBM Writer Support Routines -----------------------------*/
  144.  
  145. /* Note: Just call PutCk to write a BMHD, GRAB, DEST, SPRT, or CAMG
  146.  * chunk. As below. */
  147. #define PutBMHD(context, bmHdr)  \
  148.     PutCk(context, ID_BMHD, sizeof(BitMapHeader), (BYTE *)bmHdr)
  149. #define PutGRAB(context, point2D)  \
  150.     PutCk(context, ID_GRAB, sizeof(Point2D), (BYTE *)point2D)
  151. #define PutDEST(context, destMerge)  \
  152.     PutCk(context, ID_DEST, sizeof(DestMerge), (BYTE *)destMerge)
  153. #define PutSPRT(context, spritePrec)  \
  154.     PutCk(context, ID_SPRT, sizeof(SpritePrecedence), (BYTE *)spritePrec)
  155.  
  156. #ifdef FDwAT
  157.  
  158. /* Initialize a BitMapHeader record for a full-BitMap ILBM picture.
  159.  * This gets w, h, and nPlanes from the BitMap fields BytesPerRow, Rows, and
  160.  * Depth. It assumes you want  w = bitmap->BytesPerRow * 8 .
  161.  * CLIENT_ERROR if bitmap->BytesPerRow isn't even, as required by ILBM format.
  162.  *
  163.  * If (pageWidth, pageHeight) is (320, 200), (320, 400), (640, 200), or
  164.  * (640, 400) this sets (xAspect, yAspect) based on those 4 Amiga display
  165.  * modes. Otherwise, it sets them to (1, 1).
  166.  * 
  167.  * After calling this, store directly into the BitMapHeader if you want to
  168.  * override any settings, e.g. to make nPlanes smaller, to reduce w a little,
  169.  * or to set a position (x, y) other than (0, 0).*/
  170. extern IFFP InitBMHdr(BitMapHeader *, struct BitMap *,
  171.           /*  bmHdr,          bitmap  */
  172.      int,     int,         int,              WORD,      WORD);
  173.  /*  masking, compression, transparentColor, pageWidth, pageHeight */
  174.  /*  Masking, Compression, UWORD -- are the desired types, but get
  175.   *  compiler warnings if use them.                   */
  176.  
  177. /* Output a CMAP chunk to an open FORM ILBM write context. */
  178. extern IFFP PutCMAP(GroupContext *, WORD *,   UBYTE);
  179.         /*  context,        colorMap, depth  */
  180.  
  181. /* This procedure outputs a BitMap as an ILBM's BODY chunk with
  182.  * bitplane and mask data. Compressed if bmHdr->compression == cmpByteRun1.
  183.  * If the "mask" argument isn't NULL, it merges in the mask plane, too.
  184.  * (A fancier routine could write a rectangular portion of an image.)
  185.  * This gets Planes (bitplane ptrs) from "bitmap".
  186.  *
  187.  * CLIENT_ERROR if bitmap->Rows != bmHdr->h, or if
  188.  * bitmap->BytesPerRow != RowBytes(bmHdr->w), or if
  189.  * bitmap->Depth < bmHdr->nPlanes, or if bmHdr->nPlanes > MaxAmDepth, or if
  190.  * bufsize < MaxPackedSize(bitmap->BytesPerRow), or if
  191.  * bmHdr->compression > cmpByteRun1. */
  192. extern IFFP PutBODY(
  193.     GroupContext *, struct BitMap *, BYTE *, BitMapHeader *, BYTE *, LONG);
  194.     /*  context,           bitmap,   mask,   bmHdr,         buffer, bufsize */
  195.  
  196. #else /*not FDwAT*/
  197.  
  198. extern IFFP InitBMHdr();
  199. extern IFFP PutCMAP();
  200. extern IFFP PutBODY();
  201.  
  202. #endif FDwAT
  203.  
  204. /* ---------- ILBM Reader Support Routines -----------------------------*/
  205.  
  206. /* Note: Just call IFFReadBytes to read a BMHD, GRAB, DEST, SPRT, or CAMG
  207.  * chunk. As below. */
  208. #define GetBMHD(context, bmHdr)  \
  209.     IFFReadBytes(context, (BYTE *)bmHdr, sizeof(BitMapHeader))
  210. #define GetGRAB(context, point2D)  \
  211.     IFFReadBytes(context, (BYTE *)point2D, sizeof(Point2D))
  212. #define GetDEST(context, destMerge)  \
  213.     IFFReadBytes(context, (BYTE *)destMerge, sizeof(DestMerge))
  214. #define GetSPRT(context, spritePrec)  \
  215.     IFFReadBytes(context, (BYTE *)spritePrec, sizeof(SpritePrecedence))
  216.  
  217. /* GetBODY can handle a file with up to 16 planes plus a mask.*/
  218. #define MaxSrcPlanes 16+1
  219.  
  220. #ifdef FDwAT
  221.  
  222. /* Input a CMAP chunk from an open FORM ILBM read context.
  223.  * This converts to an Amiga color map: 4 bits each of red, green, blue packed
  224.  * into a 16 bit color register.
  225.  * pNColorRegs is passed in as a pointer to a UBYTE variable that holds
  226.  * the number of ColorRegisters the caller has space to hold. GetCMAP sets
  227.  * that variable to the number of color registers actually read.*/
  228. extern IFFP GetCMAP(GroupContext *, WORD *,   UBYTE *);
  229.         /*  context,        colorMap, pNColorRegs  */
  230.  
  231. /* GetBODY reads an ILBM's BODY into a client's bitmap, de-interleaving and
  232.  * decompressing.
  233.  *
  234.  * Caller should first compare bmHdr dimensions (rowWords, h, nPlanes) with
  235.  * bitmap dimensions, and consider reallocating the bitmap.
  236.  * If file has more bitplanes than bitmap, this reads first few planes (low
  237.  * order ones). If bitmap has more bitplanes, the last few are untouched.
  238.  * This reads the MIN(bmHdr->h, bitmap->Rows) rows, discarding the bottom
  239.  * part of the source or leaving the bottom part of the bitmap untouched.
  240.  *
  241.  * GetBODY returns CLIENT_ERROR if asked to perform a conversion it doesn't
  242.  * handle. It only understands compression algorithms cmpNone and cmpByteRun1.
  243.  * The filed row width (# words) must agree with bitmap->BytesPerRow.
  244.  *
  245.  * Caller should use bmHdr.w; GetBODY only uses it to compute the row width
  246.  * in words. Pixels to the right of bmHdr.w are not defined.
  247.  *
  248.  * [TBD] In the future, GetBODY could clip the stored image horizontally or
  249.  * fill (with transparentColor) untouched parts of the destination bitmap.
  250.  *
  251.  * GetBODY stores the mask plane, if any, in the buffer pointed to by mask.
  252.  * If mask == NULL, GetBODY will skip any mask plane. If
  253.  * (bmHdr.masking != mskHasMask) GetBODY just leaves the caller's mask alone.
  254.  *
  255.  * GetBODY needs a buffer large enough for two compressed rows.
  256.  * It returns CLIENT_ERROR if bufsize < 2 * MaxPackedSize(bmHdr.rowWords * 2).
  257.  *
  258.  * GetBODY can handle a file with up to MaxSrcPlanes planes. It returns
  259.  * CLIENT_ERROR if the file has more. (Could be due to a bum file, though.)
  260.  * If GetBODY fails, itt might've modified the client's bitmap. Sorry.*/
  261. extern IFFP GetBODY(
  262.     GroupContext *, struct BitMap *, BYTE *, BitMapHeader *, BYTE *, LONG);
  263.     /*  context,           bitmap,   mask,   bmHdr,         buffer, bufsize */
  264.  
  265. /* [TBD] Add routine(s) to create masks when reading ILBMs whose
  266.  * masking != mskHasMask. For mskNone, create a rectangular mask. For
  267.  * mskHasTransparentColor, create a mask from transparentColor. For mskLasso,
  268.  * create an "auto mask" by filling transparent color from the edges. */
  269.  
  270. #else /*not FDwAT*/
  271.  
  272. extern IFFP GetCMAP();
  273. extern IFFP GetBODY();
  274.  
  275. #endif FDwAT
  276.  
  277. #endif ILBM_H
  278.  
  279.